﻿//#include <iostream>
//#include <thread>
//#include <mutex>
//using namespace std;
//
//int x = 0;
////mutex mtx;
//
//void Add(int& x, int n, mutex& mtx)
//{
//	mtx.lock();
//	// 临界区资源
//	for (int i = 0; i < n; i++)
//	{
//		x++;
//	}
//	mtx.unlock();
//}
//
////int main()
////{
////	// 这里锁不能通过局部变量传递给函数参数 
////	// 因为在传入的时候其实进行了make_unique 操作对锁进行了开辟新的空间 进行了拷贝
////	// 这里要使用 ref 就可以解决问题
////
////	mutex mtx;
////	thread t1(Add, 100000, ref(mtx));
////	thread t2(Add, 100000, ref(mtx));
////
////	t1.join();
////	t2.join();
////
////	cout << x << endl;
////	return 0;
////}
//
//
//int main()
//{
//	// 还有一种方式 不用传 ref 锁
//	// 用 lambal 进行操作即可
//	mutex mtx;
//	int x = 0;
//	thread t1([&x, &mtx]() {
//		Add(x, 100000, mtx);
//		});
//	thread t2([&x, &mtx]() {
//		Add(x, 100000, mtx);
//		});
//
//	t1.join();
//	t2.join();
//	cout << x << endl;
//	return 0;
//}

//#include <iostream> // std::cout
//#include <chrono> // std::chrono::milliseconds
//#include <thread> // std::thread
//#include <mutex> // std::timed_mutex
//
//std::timed_mutex mtx;
//
//void fireworks(int i)
//{
//	//std::cout << i;
//	// waiting to get a lock: each thread prints "-" every 200ms:
//	while (!mtx.try_lock_for(std::chrono::milliseconds(1000)))
//	{
//		std::cout << "-";
//	}
//	std::cout << i;
//	// got a lock! - wait for 1s, then this thread prints "*"
//	std::this_thread::sleep_for(std::chrono::milliseconds(5000));
//	std::cout << "*\n";
//	mtx.unlock();
//}
//
//int main()
//{
//	std::thread threads[2];
//	// 利⽤移动赋值的⽅式，将创建的临时对象(右值对象)移动赋值给创建好的空线程对象
//	for (int i = 0; i < 2; ++i)
//		threads[i] = std::thread(fireworks, i);
//	for (auto& th : threads)
//		th.join();
//	return 0;
//}

#include <iostream>
#include <mutex>
#include <thread>
#include <vector>

//using namespace std;
std::mutex mtx;
int x = 0;

void Add(int n)
{
	// 临界区资源
	{
		//mtx.lock();
		std::lock_guard<std::mutex&> lockguard(mtx);
		for (int i = 0; i < n; i++)
		{
			x++;
		}
	}
}

int main()
{
	std::vector<std::thread> threads(2);
	for (int i = 0; i < 2; i++)
	{
		threads[i] = std::thread(Add, 100000);
	}

	for (auto& e : threads)
	{
		e.join();
	}
	std::cout << x << std::endl;
	return 0;
}

//#include <iostream>       // std::cout
//#include <thread>         // std::thread
//#include <mutex>          // std::mutex, std::lock_guard, std::adopt_lock
//#include <vector>
//std::mutex mtx;           // mutex for critical section
//
//void print_thread_id(int id) 
// {
//  // 先锁住了之后 才可以使用第二个参数 adopt_lock 
//	mtx.lock();
//	std::lock_guard<std::mutex> lck(mtx, std::adopt_lock);
//	std::cout << "thread #" << id << '\n';
//}
//
//int main()
//{
//	std::vector<std::thread> threads(10);
//	// spawn 10 threads:
//	for (int i = 0; i < 10; ++i)
//		threads[i] = std::thread(print_thread_id, i + 1);
//
//	for (auto& th : threads) th.join();
//
//	return 0;
//}